package com.jacob.androidstudy.javanote;

import java.util.*;

/**
 * 集合类的特性
 * 1. 集合对象都可以自动扩容。
 * 2. 集合中的元素必须是对象，不能是基本类型。
 * 3. 部分集合允许存放不同类型的元素。
 * 
 * 
 */
public class $13_集合类 {
	
	/**
	 * Collection
	 * 1. 是所有集合类的父接口。
	 * 2. 
	 */
	public static void collection(String[] args) {

	}
	
	/**
	 * List
	 * 1. 是Collection的子接口。也就是说，所有Collection的方法，List都有。
	 * 2. List中的元素是有序的。用户可以对列表中每个元素的插入位置进行精确地控制。
	 * 3. List中的元素允许重复。
	 * 4. List中的元素可以是不同类型的。
	 */
	public static void list(String[] args) {
//		得到一个List对象，必须实例化一个List的实现类，然后将对象赋给List变量。
		List ll = new LinkedList(); //LinkedList是List的一个实现类，底层使用链表结构。
		List al = new ArrayList(); //ArrayList是List的一个实现类，底层使用数组结构。
		List vec = new Vector(); // Vector是List的一个实现类，实现了线程安全。
		
//		向List中增加元素。
		ll.add("123"); //此方法还会返回是否成功。
		al.add(2, "123"); //向第2个位置，插入“123”。将当前处于该位置的元素（如果有的话）和所有后续元素向右移动（在其索引中加 1）。第1个参数值，不能大于size()。
		
//		返回指定位置的元素
		ll.get(2);
		al.get(2);
		
//		搜索元素
		ll.indexOf("123"); //返回中第1次出现“123”对象的索引；如果此List不包含该元素，则返回 -1。
		al.lastIndexOf("123"); //返回中第后1次出现“123”对象的索引；如果此List不包含该元素，则返回 -1。
		
//		从List中删除元素
		ll.remove(2); //移除列表中第2个位置的元素，并将该元素返回。
		al.remove("123"); //从此列表中移除第一次出现的指定元素（如果存在）。
		
//		删除所有元素
		ll.clear();
		
//		返回List的元素数
		al.size();
		
//		使用foreach遍历List
		for(Object tem:ll)
			System.out.println(tem);
		
//		使用迭代器遍历List
		for(Iterator tem = al.iterator();tem.hasNext();) {
			tem.next(); //返回下一个元素。
			tem.remove(); //删除next()返回的最后一个元素，每次调用next()后只能调用一次此方法。
		}
		
//		使用List迭代器正序遍历List
		for(ListIterator tem=al.listIterator();tem.hasNext();) {
			tem.next(); //返回下一个元素。
			tem.nextIndex(); //返回下一个元素的索引位置。
			tem.add("123"); //将指定的元素插入到next()返回的下一个元素的前面（如果有），或者previous()返回的下一个元素之后（如果有）。如果列表没有元素，那么新元素就成为列表中的唯一元素。
			tem.set("123"); //用指定元素替换next()或previous()返回的最后一个元素。只有在最后一次调用next()或previous()后，既没有调用remove()也没有调用add()时才可以调用本方法。
			tem.remove(); //删除next()或者previous()返回的最后一个元素，每次调用next()或者previous()后只能调用一次此方法。
		}
		
//		使用List迭代器倒序遍历List
		for(ListIterator tem=al.listIterator(al.size());tem.hasPrevious();) {
			tem.previous(); //返回下一个元素。
			tem.previousIndex(); //返回下一个元素的索引位置。
			tem.add("123"); //将指定的元素插入到next()返回的下一个元素的前面（如果有），或者previous()返回的下一个元素之后（如果有）。如果列表没有元素，那么新元素就成为列表中的唯一元素。
			tem.set("123"); //用指定元素替换next()或previous()返回的最后一个元素。只有在最后一次调用next()或previous()后既没有调用remove()也没有调用add()时才可以调用本方法。
			tem.remove(); //删除next()或者previous()返回的最后一个元素，每次调用next()或者previous()后只能调用一次此方法。
		}
		
		
	}
	
	/**
	 * Set
	 * 1. 是Collection的子接口。也就是说，所有Collection的方法，Set都有。
	 * 2. Set中的元素是无序的。
	 * 3. Set不允许元素重复。Set使用hashCode、equals方法判断是否重复。
	 */
	public static void set(String[] args) {
//		得到一个Set对象，必须实例化一个Set的实现类，然后将对象赋给Set变量。
		Set hs1 = new HashSet(); //HashSet是Set的一个实现类，底层使用哈希散列结构。
		Set hs2 = new HashSet(10,0.75f); //第1个参数是hs2的初始化容量，第2个参数表示hs2的元素存放数达到总容量的75%就会扩容。
		
//		如果Set中尚未存在指定的元素，则添加此元素。
//		HashSet使用hashCode算出存放下标。若该下标位置已有对象，则看A.equals(B)是否返回true。若返回true，则不会添加此元素。 
		hs1.add("123");
		
//		如果Set包含指定的元素，则返回 true。
		hs1.contains("123");
		
//		如果Set中存在指定的元素，则将其移除。
		hs1.remove("123"); //从此列表中移除第一次出现的指定元素（如果存在）。
		
//		删除所有元素
		hs1.clear();
		
//		返回Set的元素数
		hs1.size();
		
//		使用foreach遍历Set
		for(Object tem:hs1)
			System.out.println(tem);
		
//		使用迭代器遍历Set
		for(Iterator tem = hs1.iterator();tem.hasNext();) {
			tem.next(); //返回下一个元素。
			tem.remove(); //删除next()返回的最后一个元素，每次调用next()后只能调用一次此方法。
		}
	}
	
	/**
	 * SortedSet
	 * 1. 是Set的子接口。也就是说，所有Set的方法，SortedSet都有。
	 * 2. SortedSet中存放的元素需要实现java.lang.Comparable接口，或者构造一个带比较器的SortedSet。（后者优先级高）
	 * 3. SortedSet中只能存放相同类型的、不同大小（compare或者compareTo方法返回值不为0）的对象。
	 * 4. SortedSet中的元素是按照从小到大的顺序来排列的。
	 */
	public static void sortedSet(String[] args) {
//		得到一个SortedSet对象，必须实例化一个SortedSet的实现类，然后将对象赋给SortedSet变量。
		SortedSet ts1 = new TreeSet(); //TreeSet是SortedSet的一个实现类，底层使用二叉树结构。
		SortedSet ts2 = new TreeSet(new Comparator() {
			@Override
			public int compare(Object o1, Object o2) {
				return 0;
			}
		}); //构造一个新的空TreeSet，它根据指定比较器进行排序。
		
//		如果SortedSet中尚未存在指定的元素，则添加此元素。
		ts1.add("123");
		ts2.add("123");
		
//		如果SortedSet包含指定的元素，则返回 true。
		ts1.contains("123");
		
//		如果SortedSet中存在指定的元素，则将其移除。
		ts2.remove("123"); //从此列表中移除第一次出现的指定元素（如果存在）。
		
//		删除所有元素
		ts1.clear();
		
//		返回SortedSet的元素数
		ts2.size();
		
//		返回SortedSet中当前第一个（最小）元素
		ts1.first();
		
//		返回SortedSet中当前最后一个（最大）元素
		ts2.last();
		
//		返回对此SortedSet中的元素进行排序的比较器；如果SortedSet使用其元素的自然顺序，则返回 null。
		ts1.comparator();
		
//		使用foreach遍历SortedSet
		for(Object tem:ts1)
			System.out.println(tem);
		
//		使用迭代器遍历SortedSet
		for(Iterator tem = ts2.iterator();tem.hasNext();) {
			tem.next(); //返回下一个元素。
			tem.remove(); //删除next()返回的最后一个元素，每次调用next()后只能调用一次此方法。
		}

	}
	
	/**
	 * Map(映射/键值对)
	 * 1.Map中的一条记录由两个对象组成. 键--值.
	 * 2.Key不能重复, Value可以重复.
	 * 3.加一条已存在的Key-Value进去, 会更新原来的Key-Value.
	 * 4.Map常用的实现类有: HashMap HashTable(线程安全) Properties(Key-Value都是String)
	 * 
	 */
	public static void Map(String[] args) {
		Map m = new HashMap();
		
//		增加元素
		m.put("王超", "男");
		m.put("刘鹏飞", "男");
		m.put("李宇春", "男");
		m.put("李宇春", 23);
		
//		用迭代器遍历Map
		for(Iterator tem=m.keySet().iterator();tem.hasNext();) {
			System.out.println(m.get(tem.next()));
		}
		
	}
	
	/**
	 * SortedMap(排好序的映射/键值对)
	 * 1.SortedMap作为Map的子接口, 具有Map的所有特征.
	 * 1.存放的Key需要实现Comparable接口, 或者构造一个带比较器的SortedMap. (并且后者优先级高)
	 * 2.只能存放同类型 && 不同大小的Key. Comparable方法返回0, 既是两个对象大小相同.
	 * 3.存放的Key是按照从小到大排列的.
	 * 4.SortedSet常用的实现类有TreeMap.
	 * 
	 */
	public void sortedMap() {
		SortedMap sm=new TreeMap();
		
//		增加元素
		sm.put("王超", "男");
		sm.put("刘鹏飞", "男");
		sm.put("李宇春", "男");
		sm.put("李宇春", 23);
		
//		用迭代器遍历Map
		for(Iterator tem=sm.keySet().iterator();tem.hasNext();) {
			System.out.println(sm.get(tem.next()));
		}
	}
}
